import {
	getUserCodeApi, // 手机验证码
	getUserLoginApi, // 手机验证码登录
	getUpdateUserInfoApi,
	getUserIosLoginApi, // IOS授权登录
	getUserAutoLoginApi, // 手机一键登录
	getUpdatePhoneApi,
	getUserInfoApi,
	getUserWechatAuthApi, // 微信code login
	getUserWxLoginApi, // APP微信code login
} from '@/setupproject/INTERFACE'

import {
	setAsyncFunWait,
} from '@/setupproject/TOOLS_FUN'

// 配置登录类型与优先级
import commonConfigs from "@/setupproject/BASE_CONFIG";
let loginConfigs = [];
if(commonConfigs.setAppLoginType) {
	commonConfigs.setAppLoginType().then(res => {
		loginConfigs = res;
	})
}

export const MUTATIONS = {
	PHONE_SET_FUN: 'PHONE_SET_FUN',
	SHOW_AUTH_USER_INFO_SET_FUN: 'SHOW_AUTH_USER_INFO_SET_FUN',
	SHOW_AUTH_PHONE_SET_FUN: 'SHOW_AUTH_PHONE_SET_FUN',
	TOKEN_SET_FUN: "TOKEN_SET_FUN",
	TOKEN_TIMEOUT_SET_FUN: 'TOKEN_TIMEOUT_SET_FUN',
	LOGINING_SET_FUN: 'LOGINING_SET_FUN',
	USER_INFO_SET_FUN: 'USER_INFO_SET_FUN',
	PRIVACY_SHOW_SET_FUN: "PRIVACY_SHOW_SET_FUN", // 小程序隐私保护指引设置
	PRIVACY_NAME_SET_FUN: "PRIVACY_NAME_SET_FUN", // 小程序隐私保护指引设置
	PRIVACY_HIDE_SET_FUN: "PRIVACY_HIDE_SET_FUN", // 小程序隐私保护指引设置
	BOX_INDEX_SET_FUN: 'BOX_INDEX_SET_FUN',
};

export const ACTIONS = {
	SHOW_LOGIN_APP_GET_FUN: 'SHOW_LOGIN_APP_GET_FUN', // 支付前验证是否已登录
	SHOW_OFFICE_PRIVACY_GET_FUN: 'SHOW_OFFICE_PRIVACY_GET_FUN', // 小程序隐私保护指引设置
	LOGIN_GET_FUN: 'LOGIN_GET_FUN',
	RE_LOGIN_GET_FUN: 'RE_LOGIN_GET_FUN',
	AUTH_USER_INFO_GET_FUN: 'AUTH_USER_INFO_GET_FUN',
	AUTH_PHONE_GET_FUN: 'AUTH_PHONE_GET_FUN',
	USER_INFO_GET_FUN: 'USER_INFO_GET_FUN',
	JUDGE_TOKEN_GET_FUN: 'JUDGE_TOKEN_GET_FUN',
}

export default {
	state: {
		showAuthPhoneUsers: false,
		officialShowPrivacyUsers: false, // 小程序隐私保护指引设置
		privacyContractName: '', // 小程序隐私保护指引设置
		hidePrivacyUsers:false, // 小程序隐私保护指引设置
		boxSubIndex: 1,
		token: uni.getStorageSync('token'),
		tokenTimeoutUsers: 0,
		loginingUsers: false,
		userInfo: {},
		phone: '',
		showAuthUserInfoUsers: false,
	},
	getters: {
		isAuthUserInfoUsers: state => state.userInfo.nickname,
		isAuthPhoneUsers: state => state.phone,
		phone: state => state.phone,
		officialShowPrivacyUsers: state => state.officialShowPrivacyUsers, // 小程序隐私保护指引设置
		privacyContractName: state => state.privacyContractName, // 小程序隐私保护指引设置
		hidePrivacyUsers: state => state.hidePrivacyUsers, // 小程序隐私保护指引设置
		boxSubIndex: state => state.boxSubIndex,
		token: state => state.token,
		tokenTimeoutUsers: state => state.tokenTimeoutUsers,
		loginingUsers: state => state.loginingUsers,
		userInfo: state => state.userInfo,
		showAuthUserInfoUsers: state => state.showAuthUserInfoUsers,
		showAuthPhoneUsers: state => state.showAuthPhoneUsers,
	},
	mutations: {
		
		[MUTATIONS.SHOW_AUTH_USER_INFO_SET_FUN](state, data) {
			state.showAuthUserInfoUsers = data
		},
		[MUTATIONS.SHOW_AUTH_PHONE_SET_FUN](state, data) {
			state.showAuthPhoneUsers = data
		},
		// 小程序隐私保护指引设置
		[MUTATIONS.PRIVACY_SHOW_SET_FUN](state, data) {
			state.officialShowPrivacyUsers = data;
		},
		// 小程序隐私保护指引设置
		[MUTATIONS.PRIVACY_NAME_SET_FUN](state, data) {
			state.privacyContractName = data;
		},
		// 小程序隐私保护指引设置
		[MUTATIONS.PRIVACY_HIDE_SET_FUN](state, data) {
			state.hidePrivacyUsers = data;
		},
		[MUTATIONS.BOX_INDEX_SET_FUN](state, data) {
			state.boxSubIndex = data
		},
		[MUTATIONS.TOKEN_SET_FUN](state, data) {
			uni.setStorageSync('token', data);
			uni.setStorageSync('token-time', (new Date()).getTime());
			state.token = data
		},
		[MUTATIONS.TOKEN_TIMEOUT_SET_FUN](state, data) {
			state.tokenTimeoutUsers = data
		},
		[MUTATIONS.LOGINING_SET_FUN](state, data) {
			state.loginingUsers = data
		},
		[MUTATIONS.USER_INFO_SET_FUN](state, data) {
			state.userInfo = data || {}
		},
		[MUTATIONS.PHONE_SET_FUN](state, data) {
			state.phone = data
			state.userInfo.phone = data
		},
		
	},
	actions: {
		// 支付前验证是否已登录
		[ACTIONS.SHOW_LOGIN_APP_GET_FUN](store, data) {
			return new Promise(async (resolve, reject) => {
				// #ifdef APP-PLUS
				// 如果上一页是登陆页，则不自动进入登陆页
				if (!store.getters.token) {
					uni.showToast({
						title: '亲,请先登录~',
						icon: 'error',
						mask: true,
					})
		
					await setAsyncFunWait(400)
		
					//处理手机号一键登录和手机帐密登陆 ： 预登录判断当前设备是否支持一键登录
					uni.preLogin({
						provider: 'univerify',
						success: async () => {
							await store.dispatch('LOGIN_GET_FUN', {
								loginType: 'univerify'
							})
							await uni.hideLoading();
						},
						fail: (res) => {
							// 预登录失败 跳转 登陆页
							uni.navigateTo({
								url: '/app_page/login/login'
							})
							
							uni.hideLoading();
						},
						complete: e => {
							uni.hideLoading();
						}
					})
					return resolve(true);
				} else {
					return resolve(false);
				};
				// #endif
				return resolve(false);
			})
		},
		
		/**
		 * @Description: 登陆
		 */
		[ACTIONS.LOGIN_GET_FUN](store, {
			loginType, // 登陆类型
			params, // 其他参数
			invite_uid, // 邀请id
			welfare_tag
		}) {
			return new Promise(async (resolve, reject) => {
				
				// #ifdef MP-WEIXIN
				if (store.getters.token && (!invite_uid && !welfare_tag)) {
					return resolve();
				};
				// #endif
				
				// #ifdef APP-PLUS
				if(loginType === 'init'){
					return resolve();
				}
				
				if (store.getters.token) {
					store.dispatch(ACTIONS.USER_INFO_GET_FUN)
					return resolve();
				};
				
				store.commit('LOGINING_SET_FUN', true)
				
				uni.showLoading({
					title: '',
					mask: true
				});
				// #endif
				
				// APP 登录类型loginType ["weixin", "univerify", "username", "smsCode", "apple"]
				// 小程序 登陆类型loginType：mp
				if (['weixin', 'apple', 'mp'].includes(loginType) || !loginType) {
					// 微信登陆
					return uni.login({
					    provider: (!loginType || loginType === 'mp' ? 'weixin' : loginType),
						async success(res) {
							try {
								// 登陆参数
								let loginParams = {}
								
								// 登陆接口返回数据
								let returnParams = {};
								
								if (loginType === 'weixin') {
									
									// APP微信登陆
									loginParams = {
										...res.authResult,
										wx_appid: store.rootState.commonStore.commonWechatLogin.wechatOpenAppId || commonConfigs.wechatOpenAppId, // APP应用的appid
									}
									
									// APP微信
									returnParams = await getUserWxLoginApi(loginParams)
									
								} else if (loginType === 'apple') {
									// APP APPLE登陆
									loginParams = {
										client_user: res.appleInfo.user,
										identity_token: res.appleInfo.identityToken,
									}
									
									// IOS登录
									returnParams = await getUserIosLoginApi(loginParams)
									
								} else {
									// 监听路径携带的参数
									let commonMpQuery = store.rootState.commonStore.commonMpQuery || {}; 
									
									// 小程序登录
									loginParams = {
										code: res.code,
										...commonMpQuery,
									}
														
									// 二维码邀请uid
									if (invite_uid) {
										loginParams.invite_uid = invite_uid;
									}
									// #ifdef MP-WEIXIN
									//小程序path分享场景  福利屋分享welfare_tag
									if(welfare_tag){
										loginParams.welfare_tag = welfare_tag;
									}
									// #endif
									returnParams = await getUserWechatAuthApi(loginParams)
									
								}
								
								store.commit('LOGINING_SET_FUN', false)
					
								if (returnParams.code === 200) {
									// #ifdef APP-PLUS
									uni.showToast({
									    icon: "success",
									    title: returnParams.msg,
									    duration: 2000,
									})
									
									await setAsyncFunWait(1000)
									// #endif
									
									
									store.commit('TOKEN_SET_FUN', returnParams.data.token)
									store.commit('TOKEN_TIMEOUT_SET_FUN', returnParams.data.timeout)
									store.commit('USER_INFO_SET_FUN', returnParams.data.user_info)
									store.commit('PHONE_SET_FUN', returnParams.data.user_info.phone)
									
									
									// #ifdef APP-PLUS
									// 如果当前是登陆页，则回退到内容页
									let pages = getCurrentPages();
									let currPage = null;
									if (pages.length && pages[pages.length - 1]) {
									    currPage = pages[pages.length - 1];
									    if (currPage.route === "app_page/login/login") {
									        setTimeout(() => {
									            uni.navigateBack({ // 回退上一页
									
									            })
									        }, 1000)
									    }
									}
									// #endif
									
									return resolve();
								}
					
								uni.showToast({
									title: returnParams.msg,
									icon: 'error'
								})
								reject();
					
							} catch (e) {
								reject()
								store.commit('LOGINING_SET_FUN', false)
							}
						},
						fail(err) {
							reject();
							uni.showToast({
								title: err.errMsg + '，请重新登录',
								icon: 'error'
							})
						},
						complete(ending) {
						    store.commit('LOGINING_SET_FUN', false)
						    uni.hideLoading();
						}
					})
				}
				
				// 手机号一键登录
				if (loginType === 'univerify') {
					// 根据@/setupproject/commonConfigs setAppLoginType显隐第三方登陆按钮
					let otherLoginBtns = []
					loginConfigs.forEach((item => {
						if (item.typeName === "weixin") {
							otherLoginBtns.push({
								"provider": "weixin",
								"iconPath": "/static/apps/login/wechat.png" // 图标路径仅支持本地图片
							})
						}
						if (item.typeName === "apple") {
							otherLoginBtns.push({
								"provider": "apple",
								"iconPath": "/static/apps/login/apple.png" // 图标路径仅支持本地图片
							})
						}
					}))
				
					return uni.login({
						provider: 'univerify',
						univerifyStyle: {
							"fullScreen": true, // 是否全屏显示，默认值： false
							"backgroundColor": "#ffffff", // 授权页面背景颜色，默认值：#ffffff
							"backgroundImage": "", // 全屏显示的背景图片，默认值："" （仅支持本地图片，只有全屏显示时支持）  
							"icon": {
								"path": "static/phone-logo.png" // 自定义显示在授权框中的logo，仅支持本地图片 默认显示App logo   
							},
							"closeIcon": {
								// "path": "static/xxx.png" // 自定义关闭按钮，仅支持本地图片。 HBuilderX3.3.7+版本支持
							},
							"phoneNum": {
								"color": "#202020" // 手机号文字颜色 默认值：#202020  
							},
							"slogan": {
								"color": "#BBBBBB" //  slogan 字体颜色 默认值：#BBBBBB  
							},
							"authButton": {
								"normalColor": "#3479f5", // 授权按钮正常状态背景颜色 默认值：#3479f5  
								"highlightColor": "#2861c5", // 授权按钮按下状态背景颜色 默认值：#2861c5（仅ios支持）  
								"disabledColor": "#73aaf5", // 授权按钮不可点击时背景颜色 默认值：#73aaf5（仅ios支持）  
								"textColor": "#ffffff", // 授权按钮文字颜色 默认值：#ffffff  
								"title": "本机号码一键登录", // 授权按钮文案 默认值：“本机号码一键登录”  
								"borderRadius": "24px" // 授权按钮圆角 默认值："24px" （按钮高度的一半）
							},
							"otherLoginButton": {
								"visible": true, // 是否显示其他登录按钮，默认值：true  
								"normalColor": "", // 其他登录按钮正常状态背景颜色 默认值：透明 
								"highlightColor": "", // 其他登录按钮按下状态背景颜色 默认值：透明 
								"textColor": "#656565", // 其他登录按钮文字颜色 默认值：#656565  
								"title": "其他登录方式", // 其他登录方式按钮文字 默认值：“其他登录方式”  
								"borderColor": "", //边框颜色 默认值：透明（仅iOS支持）  
								"borderRadius": "0px" // 其他登录按钮圆角 默认值："24px" （按钮高度的一半）
							},
							"privacyTerms": {
								"defaultCheckBoxState": true, // 条款勾选框初始状态 默认值： true
								"uncheckedImage": "", // 可选 条款勾选框未选中状态图片（仅支持本地图片 建议尺寸 24x24px）(3.2.0+ 版本支持)   
								"checkedImage": "", // 可选 条款勾选框选中状态图片（仅支持本地图片 建议尺寸24x24px）(3.2.0+ 版本支持)   
								"checkBoxSize": 12, // 可选 条款勾选框大小，仅android支持
								"textColor": "#BBBBBB", // 文字颜色 默认值：#BBBBBB  
								"termsColor": "#5496E3", //  协议文字颜色 默认值： #5496E3  
								"prefix": "我已阅读并同意", // 条款前的文案 默认值：“我已阅读并同意”  
								"suffix": "并使用本机号码登录", // 条款后的文案 默认值：“并使用本机号码登录”  
								"privacyItems": [ // 自定义协议条款，最大支持2个，需要同时设置url和title. 否则不生效  
									{
										"url": "https://api.yizhifeiji520.com/duty/agreement", // 点击跳转的协议详情页面  
										"title": "用户服务协议" // 协议名称  
									}
								]
							},
							"buttons": { // 自定义页面下方按钮仅全屏模式生效（3.1.14+ 版本支持）
								"iconWidth": "45px", // 图标宽度（高度等比例缩放） 默认值：45px
								"list": otherLoginBtns
							}
						}, //自定义登录框样式
						async success(res) { 
				
							try {
								const loginParams = {
									openid: res.authResult.openid,
									access_token: res.authResult.access_token,
								}
				
								const {
									data,
									code,
									msg
								} = await getUserAutoLoginApi(loginParams)
				
								store.commit('LOGINING_SET_FUN', false)
								uni.hideLoading();
				
								uni.closeAuthView() //关闭一键登录弹出窗口
								
								if (code === 200) {
									uni.showToast({
										icon: "success",
										title: msg,
										duration: 2000,
									})
									
									await setAsyncFunWait(1000)
									
									store.commit('TOKEN_SET_FUN', data.token)
									store.commit('TOKEN_TIMEOUT_SET_FUN', data.timeout)
									store.commit('USER_INFO_SET_FUN', data.user_info)
									store.commit('PHONE_SET_FUN', data.phone)
									
									return resolve();
								}
				
								uni.showToast({
									title: msg,
									icon: 'error'
								})
								reject();
				
							} catch (e) {
								reject();
								store.commit('LOGINING_SET_FUN', false);
								uni.hideLoading();
							}
						},
						fail(res) {
							uni.closeAuthView() //关闭一键登录弹出窗口
							reject();
				
							if (res.errMsg.indexOf('用户点击了其他登录方式') > -1) {
								return uni.navigateTo({
									url: '/app_page/login/login'
								})
							}
				
							// 微信登陆
							if (res.provider === 'weixin') {
								store.dispatch('LOGIN_GET_FUN', {loginType: 'weixin'})
							}
				
							// ios登陆
							if (res.provider === 'apple') {
								store.dispatch('LOGIN_GET_FUN', {loginType: 'apple'})
							}
						}
					});
				}
				
				// 手机验证码
				if (loginType === 'smsCode') {
					
					try {
						const loginParams = params

						const {
							data,
							code,
							msg
						} = await getUserLoginApi(loginParams)
					
						store.commit('LOGINING_SET_FUN', false)
						uni.hideLoading();
					
						if (code === 200) {
							uni.showToast({
								icon: "success",
								title: msg,
								duration: 1800,
							})
							
							await setAsyncFunWait(1000)
							
							store.commit('TOKEN_SET_FUN', data.token)
							store.commit('TOKEN_TIMEOUT_SET_FUN', data.timeout)
							store.commit('USER_INFO_SET_FUN', data.user_info)
							store.commit('PHONE_SET_FUN', data.user_info.phone)
					
							// 如果当前是登陆页，则回退到内容页
							let pages = getCurrentPages();
							let currPage = null;
							if (pages.length && pages[pages.length - 1]) {
								currPage = pages[pages.length - 1];
								if (currPage.route === "app_page/login/login") {
									setTimeout(() => {
										uni.navigateBack({ // 回退上一页
					
										})
									}, 1000)
								}
							}
					
							return resolve();
						}
						
						// 账号注销
						if(params.phone === commonConfigs.references_phone && code === 10004) {
							return reject();
						}
					
						uni.showToast({
							title: msg,
							icon: 'error'
						})
						reject();
					
					} catch (e) {
						reject()
						store.commit('LOGINING_SET_FUN', false)
						uni.hideLoading();
					
					}
					return;
				}
				
			})
		},

		async [ACTIONS.RE_LOGIN_GET_FUN](store, data) {
			if (store.getters.loginingUsers) return;
			
			await store.commit('TOKEN_SET_FUN', '');
			await store.commit('USER_INFO_SET_FUN', {});
			await store.commit('PHONE_SET_FUN', '');
			
			// #ifdef MP-WEIXIN
			await store.dispatch('LOGIN_GET_FUN', {loginType: 'mp'});
			// #endif
		},

		[ACTIONS.AUTH_USER_INFO_GET_FUN](store) {
			uni.getUserProfile({
				desc: '您的信息展示在抽赏、赏袋、我的...',
				async success(res) {
					const {
						userInfo
					} = res;
					const data = {
						"province": userInfo.province,
						"city": userInfo.city,
						"gender": userInfo.gender,
						"nickname": userInfo.nickName,
						"avatar": userInfo.avatarUrl,
						"country": userInfo.country,
					}
					store.commit('SHOW_AUTH_USER_INFO_SET_FUN', false)
					await getUpdateUserInfoApi(data)
					store.dispatch(ACTIONS.USER_INFO_GET_FUN)
				},
				fail(e) {
					console.error(e);
				},
			})
		},

		async [ACTIONS.AUTH_PHONE_GET_FUN](store, data) {
			if (!data.iv) {
				console.log(data,'data--------------------------------------------');
				return uni.showToast({
					title: '亲~您拒绝了授权...',
					icon: "none"
				});
			}
			
			if(uni.getStorageSync('isFromShopRecord')){
				await store.dispatch('RE_LOGIN_GET_FUN');
				await (uni.setStorageSync('isFromShopRecord', false))
			}

			const {
				data: result
			} = await getUpdatePhoneApi(data)
			await store.commit(MUTATIONS.SHOW_AUTH_PHONE_SET_FUN, false);
			
			if(result) {
				await store.commit('PHONE_SET_FUN', result.phone)
			}

			// 如果存在token，同步小程序数据
			if (result && result.token) {
				await store.commit('TOKEN_SET_FUN', result.token)
				await store.dispatch(ACTIONS.USER_INFO_GET_FUN);
			}

			await store.dispatch('RE_LOGIN_GET_FUN');
		},

		async [ACTIONS.USER_INFO_GET_FUN](store, data) {
			const {
				data: result
			} = await getUserInfoApi()

			store.commit(MUTATIONS.USER_INFO_SET_FUN, result);
			store.commit('PHONE_SET_FUN', result ? result.phone : '')
		},
		async [ACTIONS.SHOW_OFFICE_PRIVACY_GET_FUN](store, data){
			if(!uni.getPrivacySetting) {
				return false;
			}
			
			return new Promise(async (resolve, reject) => {
				if(data && data.isClickSure) {
					store.commit(MUTATIONS.PRIVACY_SHOW_SET_FUN, data.isShowPrivas);
					return resolve(false);
				}else{
					// 小程序隐私保护指引设置
					uni.getPrivacySetting({
						success: res => {
							store.commit(MUTATIONS.PRIVACY_SHOW_SET_FUN, res.needAuthorization);
							store.commit(MUTATIONS.PRIVACY_NAME_SET_FUN, res.privacyContractName);
							
							if (res.needAuthorization) {
								// 需要弹出隐私协议;
								return resolve(true);
							} else {
								// 用户已经同意过隐私协议，所以不需要再弹出隐私协议，也能调用已声明过的隐私接口
								return resolve(false);
							}
						},
						fail: () => {},
						complete: () => {}
					})
				}
			})
		
		},
	}
}